home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / dcache.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-09  |  10.7 KB  |  373 lines
  1. #ifndef __LINUX_DCACHE_H
  2. #define __LINUX_DCACHE_H
  3.  
  4. #include <asm/atomic.h>
  5. #include <linux/list.h>
  6. #include <linux/rculist.h>
  7. #include <linux/spinlock.h>
  8. #include <linux/cache.h>
  9. #include <linux/rcupdate.h>
  10.  
  11. struct nameidata;
  12. struct path;
  13. struct vfsmount;
  14.  
  15. /*
  16.  * linux/include/linux/dcache.h
  17.  *
  18.  * Dirent cache data structures
  19.  *
  20.  * (C) Copyright 1997 Thomas Schoebel-Theuer,
  21.  * with heavy changes by Linus Torvalds
  22.  */
  23.  
  24. #define IS_ROOT(x) ((x) == (x)->d_parent)
  25.  
  26. /*
  27.  * "quick string" -- eases parameter passing, but more importantly
  28.  * saves "metadata" about the string (ie length and the hash).
  29.  *
  30.  * hash comes first so it snuggles against d_parent in the
  31.  * dentry.
  32.  */
  33. struct qstr {
  34.     unsigned int hash;
  35.     unsigned int len;
  36.     const unsigned char *name;
  37. };
  38.  
  39. struct dentry_stat_t {
  40.     int nr_dentry;
  41.     int nr_unused;
  42.     int age_limit;          /* age in seconds */
  43.     int want_pages;         /* pages requested by system */
  44.     int dummy[2];
  45. };
  46. extern struct dentry_stat_t dentry_stat;
  47.  
  48. /* Name hashing routines. Initial hash value */
  49. /* Hash courtesy of the R5 hash in reiserfs modulo sign bits */
  50. #define init_name_hash()        0
  51.  
  52. /* partial hash update function. Assume roughly 4 bits per character */
  53. static inline unsigned long
  54. partial_name_hash(unsigned long c, unsigned long prevhash)
  55. {
  56.     return (prevhash + (c << 4) + (c >> 4)) * 11;
  57. }
  58.  
  59. /*
  60.  * Finally: cut down the number of bits to a int value (and try to avoid
  61.  * losing bits)
  62.  */
  63. static inline unsigned long end_name_hash(unsigned long hash)
  64. {
  65.     return (unsigned int) hash;
  66. }
  67.  
  68. /* Compute the hash for a name string. */
  69. static inline unsigned int
  70. full_name_hash(const unsigned char *name, unsigned int len)
  71. {
  72.     unsigned long hash = init_name_hash();
  73.     while (len--)
  74.         hash = partial_name_hash(*name++, hash);
  75.     return end_name_hash(hash);
  76. }
  77.  
  78. struct dcookie_struct;
  79.  
  80. #define DNAME_INLINE_LEN_MIN 36
  81.  
  82. struct dentry {
  83.     atomic_t d_count;
  84.     unsigned int d_flags;        /* protected by d_lock */
  85.     spinlock_t d_lock;        /* per dentry lock */
  86.     struct inode *d_inode;        /* Where the name belongs to - NULL is
  87.                      * negative */
  88.     /*
  89.      * The next three fields are touched by __d_lookup.  Place them here
  90.      * so they all fit in a cache line.
  91.      */
  92.     struct hlist_node d_hash;    /* lookup hash list */
  93.     struct dentry *d_parent;    /* parent directory */
  94.     struct qstr d_name;
  95.  
  96.     struct list_head d_lru;        /* LRU list */
  97.     /*
  98.      * d_child and d_rcu can share memory
  99.      */
  100.     union {
  101.         struct list_head d_child;    /* child of parent list */
  102.          struct rcu_head d_rcu;
  103.     } d_u;
  104.     struct list_head d_subdirs;    /* our children */
  105.     struct list_head d_alias;    /* inode alias list */
  106.     unsigned long d_time;        /* used by d_revalidate */
  107.     struct dentry_operations *d_op;
  108.     struct super_block *d_sb;    /* The root of the dentry tree */
  109.     void *d_fsdata;            /* fs-specific data */
  110. #ifdef CONFIG_PROFILING
  111.     struct dcookie_struct *d_cookie; /* cookie, if any */
  112. #endif
  113.     int d_mounted;
  114.     unsigned char d_iname[DNAME_INLINE_LEN_MIN];    /* small names */
  115. };
  116.  
  117. /*
  118.  * dentry->d_lock spinlock nesting subclasses:
  119.  *
  120.  * 0: normal
  121.  * 1: nested
  122.  */
  123. enum dentry_d_lock_class
  124. {
  125.     DENTRY_D_LOCK_NORMAL, /* implicitly used by plain spin_lock() APIs. */
  126.     DENTRY_D_LOCK_NESTED
  127. };
  128.  
  129. struct dentry_operations {
  130.     int (*d_revalidate)(struct dentry *, struct nameidata *);
  131.     int (*d_hash) (struct dentry *, struct qstr *);
  132.     int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
  133.     int (*d_delete)(struct dentry *);
  134.     void (*d_release)(struct dentry *);
  135.     void (*d_iput)(struct dentry *, struct inode *);
  136.     char *(*d_dname)(struct dentry *, char *, int);
  137. };
  138.  
  139. /* the dentry parameter passed to d_hash and d_compare is the parent
  140.  * directory of the entries to be compared. It is used in case these
  141.  * functions need any directory specific information for determining
  142.  * equivalency classes.  Using the dentry itself might not work, as it
  143.  * might be a negative dentry which has no information associated with
  144.  * it */
  145.  
  146. /*
  147. locking rules:
  148.         big lock    dcache_lock    d_lock   may block
  149. d_revalidate:    no        no        no       yes
  150. d_hash        no        no        no       yes
  151. d_compare:    no        yes        yes      no
  152. d_delete:    no        yes        no       no
  153. d_release:    no        no        no       yes
  154. d_iput:        no        no        no       yes
  155.  */
  156.  
  157. /* d_flags entries */
  158. #define DCACHE_AUTOFS_PENDING 0x0001    /* autofs: "under construction" */
  159. #define DCACHE_NFSFS_RENAMED  0x0002    /* this dentry has been "silly
  160.                      * renamed" and has to be
  161.                      * deleted on the last dput()
  162.                      */
  163. #define    DCACHE_DISCONNECTED 0x0004
  164.      /* This dentry is possibly not currently connected to the dcache tree,
  165.       * in which case its parent will either be itself, or will have this
  166.       * flag as well.  nfsd will not use a dentry with this bit set, but will
  167.       * first endeavour to clear the bit either by discovering that it is
  168.       * connected, or by performing lookup operations.   Any filesystem which
  169.       * supports nfsd_operations MUST have a lookup function which, if it finds
  170.       * a directory inode with a DCACHE_DISCONNECTED dentry, will d_move
  171.       * that dentry into place and return that dentry rather than the passed one,
  172.       * typically using d_splice_alias.
  173.       */
  174.  
  175. #define DCACHE_REFERENCED    0x0008  /* Recently used, don't discard. */
  176. #define DCACHE_UNHASHED        0x0010    
  177.  
  178. #define DCACHE_INOTIFY_PARENT_WATCHED    0x0020 /* Parent inode is watched */
  179.  
  180. extern spinlock_t dcache_lock;
  181. extern seqlock_t rename_lock;
  182.  
  183. /**
  184.  * d_drop - drop a dentry
  185.  * @dentry: dentry to drop
  186.  *
  187.  * d_drop() unhashes the entry from the parent dentry hashes, so that it won't
  188.  * be found through a VFS lookup any more. Note that this is different from
  189.  * deleting the dentry - d_delete will try to mark the dentry negative if
  190.  * possible, giving a successful _negative_ lookup, while d_drop will
  191.  * just make the cache lookup fail.
  192.  *
  193.  * d_drop() is used mainly for stuff that wants to invalidate a dentry for some
  194.  * reason (NFS timeouts or autofs deletes).
  195.  *
  196.  * __d_drop requires dentry->d_lock.
  197.  */
  198.  
  199. static inline void __d_drop(struct dentry *dentry)
  200. {
  201.     if (!(dentry->d_flags & DCACHE_UNHASHED)) {
  202.         dentry->d_flags |= DCACHE_UNHASHED;
  203.         hlist_del_rcu(&dentry->d_hash);
  204.     }
  205. }
  206.  
  207. static inline void d_drop(struct dentry *dentry)
  208. {
  209.     spin_lock(&dcache_lock);
  210.     spin_lock(&dentry->d_lock);
  211.      __d_drop(dentry);
  212.     spin_unlock(&dentry->d_lock);
  213.     spin_unlock(&dcache_lock);
  214. }
  215.  
  216. static inline int dname_external(struct dentry *dentry)
  217. {
  218.     return dentry->d_name.name != dentry->d_iname;
  219. }
  220.  
  221. /*
  222.  * These are the low-level FS interfaces to the dcache..
  223.  */
  224. extern void d_instantiate(struct dentry *, struct inode *);
  225. extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
  226. extern struct dentry * d_materialise_unique(struct dentry *, struct inode *);
  227. extern void d_delete(struct dentry *);
  228.  
  229. /* allocate/de-allocate */
  230. extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
  231. extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
  232. extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
  233. extern struct dentry * d_obtain_alias(struct inode *);
  234. extern void shrink_dcache_sb(struct super_block *);
  235. extern void shrink_dcache_parent(struct dentry *);
  236. extern void shrink_dcache_for_umount(struct super_block *);
  237. extern int d_invalidate(struct dentry *);
  238.  
  239. /* only used at mount-time */
  240. extern struct dentry * d_alloc_root(struct inode *);
  241.  
  242. /* <clickety>-<click> the ramfs-type tree */
  243. extern void d_genocide(struct dentry *);
  244.  
  245. extern struct dentry *d_find_alias(struct inode *);
  246. extern void d_prune_aliases(struct inode *);
  247.  
  248. /* test whether we have any submounts in a subdir tree */
  249. extern int have_submounts(struct dentry *);
  250.  
  251. /*
  252.  * This adds the entry to the hash queues.
  253.  */
  254. extern void d_rehash(struct dentry *);
  255.  
  256. /**
  257.  * d_add - add dentry to hash queues
  258.  * @entry: dentry to add
  259.  * @inode: The inode to attach to this dentry
  260.  *
  261.  * This adds the entry to the hash queues and initializes @inode.
  262.  * The entry was actually filled in earlier during d_alloc().
  263.  */
  264.  
  265. static inline void d_add(struct dentry *entry, struct inode *inode)
  266. {
  267.     d_instantiate(entry, inode);
  268.     d_rehash(entry);
  269. }
  270.  
  271. /**
  272.  * d_add_unique - add dentry to hash queues without aliasing
  273.  * @entry: dentry to add
  274.  * @inode: The inode to attach to this dentry
  275.  *
  276.  * This adds the entry to the hash queues and initializes @inode.
  277.  * The entry was actually filled in earlier during d_alloc().
  278.  */
  279. static inline struct dentry *d_add_unique(struct dentry *entry, struct inode *inode)
  280. {
  281.     struct dentry *res;
  282.  
  283.     res = d_instantiate_unique(entry, inode);
  284.     d_rehash(res != NULL ? res : entry);
  285.     return res;
  286. }
  287.  
  288. /* used for rename() and baskets */
  289. extern void d_move(struct dentry *, struct dentry *);
  290. extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
  291.  
  292. /* appendix may either be NULL or be used for transname suffixes */
  293. extern struct dentry * d_lookup(struct dentry *, struct qstr *);
  294. extern struct dentry * __d_lookup(struct dentry *, struct qstr *);
  295. extern struct dentry * d_hash_and_lookup(struct dentry *, struct qstr *);
  296.  
  297. /* validate "insecure" dentry pointer */
  298. extern int d_validate(struct dentry *, struct dentry *);
  299.  
  300. /*
  301.  * helper function for dentry_operations.d_dname() members
  302.  */
  303. #define D_PATH_FAIL_DELETED 1
  304. #define D_PATH_DISCONNECT   2
  305. extern char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
  306.  
  307. extern char *__d_path(const struct path *path, struct path *root, char *, int,
  308.               int);
  309. extern char *d_path(const struct path *, char *, int);
  310. extern char *dentry_path(struct dentry *, char *, int);
  311.  
  312. /* Allocation counts.. */
  313.  
  314. /**
  315.  *    dget, dget_locked    -    get a reference to a dentry
  316.  *    @dentry: dentry to get a reference to
  317.  *
  318.  *    Given a dentry or %NULL pointer increment the reference count
  319.  *    if appropriate and return the dentry. A dentry will not be 
  320.  *    destroyed when it has references. dget() should never be
  321.  *    called for dentries with zero reference counter. For these cases
  322.  *    (preferably none, functions in dcache.c are sufficient for normal
  323.  *    needs and they take necessary precautions) you should hold dcache_lock
  324.  *    and call dget_locked() instead of dget().
  325.  */
  326.  
  327. static inline struct dentry *dget(struct dentry *dentry)
  328. {
  329.     if (dentry) {
  330.         BUG_ON(!atomic_read(&dentry->d_count));
  331.         atomic_inc(&dentry->d_count);
  332.     }
  333.     return dentry;
  334. }
  335.  
  336. extern struct dentry * dget_locked(struct dentry *);
  337.  
  338. /**
  339.  *    d_unhashed -    is dentry hashed
  340.  *    @dentry: entry to check
  341.  *
  342.  *    Returns true if the dentry passed is not currently hashed.
  343.  */
  344.  
  345. static inline int d_unhashed(struct dentry *dentry)
  346. {
  347.     return (dentry->d_flags & DCACHE_UNHASHED);
  348. }
  349.  
  350. static inline struct dentry *dget_parent(struct dentry *dentry)
  351. {
  352.     struct dentry *ret;
  353.  
  354.     spin_lock(&dentry->d_lock);
  355.     ret = dget(dentry->d_parent);
  356.     spin_unlock(&dentry->d_lock);
  357.     return ret;
  358. }
  359.  
  360. extern void dput(struct dentry *);
  361.  
  362. static inline int d_mountpoint(struct dentry *dentry)
  363. {
  364.     return dentry->d_mounted;
  365. }
  366.  
  367. extern struct vfsmount *lookup_mnt(struct vfsmount *, struct dentry *);
  368. extern struct dentry *lookup_create(struct nameidata *nd, int is_dir);
  369.  
  370. extern int sysctl_vfs_cache_pressure;
  371.  
  372. #endif    /* __LINUX_DCACHE_H */
  373.